# 作者:小宇
# 2025年11月12日14时58分08秒
# 1225074067@qq.com
import pandas as pd
import json
import re
from pathlib import Path
import os

# 首先查看上传的Excel文件结构
file_path = './data/14商业手工业 -总数据和各朝代数据.xlsx'

# 查看Excel文件的所有sheet名称
excel_file = pd.ExcelFile(file_path)
print("Excel文件包含的sheet:")
for i, sheet in enumerate(excel_file.sheet_names, 1):
    print(f"{i}. {sheet}")

# 读取第一个sheet查看数据结构
print("\n" + "="*50)
print("第一个sheet的数据预览:")
print("="*50)
df_sample = pd.read_excel(file_path, sheet_name=0)
print(f"数据形状: {df_sample.shape}")
print(f"\n列名: {list(df_sample.columns)}")
print(f"\n前5行数据:")
print(df_sample.head())

print(f"\n数据类型:")
print(df_sample.dtypes)

# 检查是否有"时期"相关的列或第一行是否为标题
print(f"\n第一行数据:")
print(df_sample.iloc[0] if not df_sample.empty else "数据为空")


def extract_commerce_data_from_text(text):
    """从商业手工业文本中提取关键信息"""
    if pd.isna(text) or not isinstance(text, str):
        return None

    # 定义提取模式
    extracted_data = {
        'year': None,  # 年份
        'workshop_count': None,  # 作坊数量
        'shop_count': None,  # 店铺数量
        'employee_count': None,  # 从业人员数量
        'product_type': None,  # 产品类型（从专门列提取，这里先初始化）
        'location': None,  # 地点
        'scale': None,  # 规模描述
        'technology': None  # 技术水平
    }

    # 1. 提取年份（公元年份）
    year_patterns = [
        r'公元\s*(\d{3,4})\s*年',
        r'(\d{3,4})\s*年',
        r'(\d{4})\s*[年前后]',
        r'(\d{2})\s*世纪\s*(\d{2})\s*年代'  # 处理世纪年代格式
    ]

    for pattern in year_patterns:
        match = re.search(pattern, text)
        if match:
            try:
                if len(match.groups()) == 2:  # 世纪年代格式
                    century = int(match.group(1))
                    decade = int(match.group(2))
                    year = (century - 1) * 100 + decade
                    extracted_data['year'] = year
                else:
                    year = int(match.group(1))
                    # 过滤不合理的年份（1-2025之间）
                    if 1 <= year <= 2025:
                        extracted_data['year'] = year
                break
            except:
                continue

    # 2. 提取数量信息（作坊、店铺、人员）
    # 作坊数量
    workshop_match = re.search(r'(\d+)\s*(处|个|家)\s*作坊', text)
    if workshop_match:
        try:
            extracted_data['workshop_count'] = int(workshop_match.group(1))
        except:
            pass

    # 店铺数量
    shop_match = re.search(r'(\d+)\s*(处|个|家|间)\s*店铺', text)
    if shop_match:
        try:
            extracted_data['shop_count'] = int(shop_match.group(1))
        except:
            pass

    # 从业人员数量
    employee_patterns = [
        r'(\d+)\s*(人|名|个)\s*[工人工匠从业人员]',
        r'从业[人员]\s*约?\s*(\d+)\s*人'
    ]
    for pattern in employee_patterns:
        employee_match = re.search(pattern, text)
        if employee_match:
            try:
                extracted_data['employee_count'] = int(employee_match.group(1))
                break
            except:
                continue

    # 3. 提取地点信息
    location_patterns = [
        r'在\s*([^，。\s]+)\s*[设建开设]',
        r'([^，。\s]+)\s*[地地区域内]有'
    ]
    for pattern in location_patterns:
        location_match = re.search(pattern, text)
        if location_match and location_match.group(1):
            extracted_data['location'] = location_match.group(1)
            break

    # 4. 提取规模描述
    scale_keywords = ['大型', '中型', '小型', '规模宏大', '规模较大', '规模较小', '作坊林立', '店铺密集']
    for keyword in scale_keywords:
        if keyword in text:
            extracted_data['scale'] = keyword
            break

    # 5. 提取技术水平描述
    tech_keywords = ['先进', '精湛', '熟练', '传统', '改良', '创新', '手工', '机械', '半机械']
    for keyword in tech_keywords:
        if keyword in text:
            if extracted_data['technology']:
                extracted_data['technology'] += '、' + keyword
            else:
                extracted_data['technology'] = keyword

    return extracted_data


def extract_data_from_commerce_excel(file_path, sheet_names=None):
    """从商业手工业Excel文件中提取数据"""
    try:
        # 如果未指定sheet名称，则读取所有sheet
        if not sheet_names:
            excel_file = pd.ExcelFile(file_path)
            sheet_names = excel_file.sheet_names

        all_results = []

        for sheet_name in sheet_names:
            print(f"正在处理sheet: {sheet_name}")

            # 读取sheet数据
            df = pd.read_excel(file_path, sheet_name=sheet_name)

            # 处理列名 - 基于之前的结构，重新设置列名
            if not df.empty:
                # 检查第一行是否为实际的列标题
                if df.iloc[0, 1] == '原文' and df.iloc[0, 2] == '商业手工业类型':
                    # 跳过第一行标题，使用第二行作为数据开始
                    df_data = df.iloc[1:].reset_index(drop=True)
                    df_data.columns = ['category', 'content', 'product_type', 'source']
                else:
                    # 使用默认列名
                    if len(df.columns) >= 4:
                        df.columns = ['category', 'content', 'product_type', 'source']
                    else:
                        # 处理列数不足的情况
                        while len(df.columns) < 4:
                            df[f'Unnamed: {len(df.columns)}'] = None
                        df.columns = ['category', 'content', 'product_type', 'source']
                    df_data = df.reset_index(drop=True)

                # 处理每一行数据
                for idx, row in df_data.iterrows():
                    # 获取基础信息
                    category = str(row['category']) if not pd.isna(row['category']) else None
                    content = str(row['content']) if not pd.isna(row['content']) else None
                    product_type = str(row['product_type']) if not pd.isna(row['product_type']) else None
                    source = str(row['source']) if not pd.isna(row['source']) else None

                    # 只处理有时期和内容的记录
                    if category and content and category != 'nan' and content != 'nan':
                        # 从文本中提取详细信息
                        extracted_detail = extract_commerce_data_from_text(content)

                        # 创建完整记录
                        record = {
                            'category': category.strip(),  # 时期/朝代
                            'content': content.strip(),  # 原文内容
                            'product_type': product_type.strip() if product_type and product_type != 'nan' else None,
                            # 产品类型
                            'source': source.strip() if source and source != 'nan' else None,  # 出处
                            'year': extracted_detail['year'],
                            'workshop_count': extracted_detail['workshop_count'],
                            'shop_count': extracted_detail['shop_count'],
                            'employee_count': extracted_detail['employee_count'],
                            'location': extracted_detail['location'],
                            'scale': extracted_detail['scale'],
                            'technology': extracted_detail['technology']
                        }

                        # 添加到结果列表（至少保留基础信息）
                        all_results.append(record)

        print(f"\n数据提取完成，共提取 {len(all_results)} 条记录")
        return all_results

    except Exception as e:
        print(f"读取文件时出错: {str(e)}")
        import traceback
        traceback.print_exc()
        return []


def save_commerce_data_to_json(data, output_file):
    """将提取的商业手工业数据保存为JSON文件"""
    try:
        # 创建输出目录
        output_dir = os.path.dirname(output_file)
        if output_dir and not os.path.exists(output_dir):
            os.makedirs(output_dir, exist_ok=True)

        # 保存为JSON文件（带缩进，便于阅读）
        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump(data, f, ensure_ascii=False, indent=2)

        print(f"数据已成功保存到: {output_file}")
        return True

    except Exception as e:
        print(f"保存文件时出错: {str(e)}")
        return False


def analyze_commerce_data(data):
    """分析提取的商业手工业数据"""
    if not data:
        print("没有可分析的数据")
        return

    print("\n" + "=" * 60)
    print("商业手工业数据提取结果分析")
    print("=" * 60)

    # 1. 时期分布统计
    category_count = {}
    for record in data:
        category = record['category']
        if category in category_count:
            category_count[category] += 1
        else:
            category_count[category] = 1

    print(f"\n1. 各时期记录数量分布:")
    sorted_categories = sorted(category_count.items(), key=lambda x: x[1], reverse=True)
    for i, (category, count) in enumerate(sorted_categories[:10], 1):  # 显示前10个
        print(f"   {i:2d}. {category:<10} : {count:4d} 条")
    if len(sorted_categories) > 10:
        print(f"   ... 还有 {len(sorted_categories) - 10} 个时期类别")

    # 2. 有效数据字段统计
    field_stats = {
        'year': 0,
        'workshop_count': 0,
        'shop_count': 0,
        'employee_count': 0,
        'product_type': 0,
        'location': 0,
        'scale': 0,
        'technology': 0
    }

    for record in data:
        for field in field_stats.keys():
            if record[field] is not None and record[field] != '':
                field_stats[field] += 1

    print(f"\n2. 各字段有效数据统计:")
    total_records = len(data)
    for field, count in field_stats.items():
        percentage = (count / total_records) * 100 if total_records > 0 else 0
        print(f"   {field:<15} : {count:4d} 条 ({percentage:5.1f}%)")

    # 3. 产品类型统计（前10）
    product_stats = {}
    for record in data:
        product = record['product_type']
        if product and product != 'nan' and product != '':
            # 处理多个产品类型的情况（用分号分隔）
            products = [p.strip() for p in product.split('；') if p.strip()]
            for p in products:
                if p in product_stats:
                    product_stats[p] += 1
                else:
                    product_stats[p] = 1

    print(f"\n3. 主要产品类型统计（前10）:")
    if product_stats:
        sorted_products = sorted(product_stats.items(), key=lambda x: x[1], reverse=True)
        for i, (product, count) in enumerate(sorted_products[:10], 1):
            print(f"   {i:2d}. {product:<15} : {count:3d} 条")
    else:
        print("   暂无产品类型数据")

    # 4. 年份分布（只统计有年份的记录）
    year_records = [r for r in data if r['year'] is not None]
    if year_records:
        years = [r['year'] for r in year_records]
        min_year = min(years)
        max_year = max(years)
        print(f"\n4. 年份分布:")
        print(f"   时间跨度: {min_year} 年 - {max_year} 年")
        print(f"   有年份记录数: {len(year_records)} 条")

        # 按世纪分组统计
        century_stats = {}
        for year in years:
            century = (year // 100) + 1 if year % 100 != 0 else year // 100
            century_key = f"{century}世纪"
            if century_key in century_stats:
                century_stats[century_key] += 1
            else:
                century_stats[century_key] = 1

        print(f"   各世纪记录分布:")
        sorted_centuries = sorted(century_stats.items(), key=lambda x: int(x[0].replace('世纪', '')))
        for century, count in sorted_centuries:
            print(f"     {century:<6} : {count:3d} 条")


def main_commerce_data_processing(input_file, output_file):
    """商业手工业数据处理主函数"""
    print("=" * 70)
    print("开始商业手工业数据处理流程")
    print("=" * 70)

    # 1. 提取数据（处理所有sheet）
    print(f"\n1. 正在从Excel文件提取数据: {input_file}")
    commerce_data = extract_data_from_commerce_excel(input_file)

    if not commerce_data:
        print("数据提取失败，程序终止")
        return None

    # 2. 分析数据
    print(f"\n2. 正在分析提取的数据")
    analyze_commerce_data(commerce_data)

    # 3. 保存数据
    print(f"\n3. 正在保存数据到JSON文件")
    save_success = save_commerce_data_to_json(commerce_data, output_file)

    if save_success:
        print(f"\n数据处理完成！")
        print(f"输出文件: {output_file}")
        print(f"总记录数: {len(commerce_data)} 条")

        # 显示前2条记录作为示例
        print(f"\n前2条记录示例:")
        for i, record in enumerate(commerce_data[:2], 1):
            print(f"\n示例 {i}:")
            for key, value in record.items():
                print(f"  {key:<15} : {value if value is not None else 'None'}")

    return commerce_data


# 执行数据处理
if __name__ == '__main__':
    # 配置文件路径
    INPUT_EXCEL = './data/14商业手工业 -总数据和各朝代数据.xlsx'
    OUTPUT_JSON = './outputs/commerce_handicraft_data.json'

    # 运行主函数
    processed_data = main_commerce_data_processing(INPUT_EXCEL, OUTPUT_JSON)